package com.manage.utils;

import org.apache.commons.lang3.StringUtils;
import org.springframework.util.Assert;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

/**
 * <b>Function</b> 字符串处理工具类 ,还有另外一个StringConvert.java
 * 
 * @author jax
 */
public class Str2Utils extends StringUtils {

	public Str2Utils() {

	}

	private final static String STRING_NULL="null";

	/**
	 * 检查传入的参数是否为空。
	 * 
	 * @return boolean 如果被检查值为null，返回true。 <br>
	 *         如果value的类型为String，并且value.length()为0，返回true。<br>
	 *         如果value的类型为Object[]，并且value.length为0，返回true。 <br>
	 *         如果value的类型为Collection，并且value.size()为0，返回true。 <br>
	 *         如果value的类型为Dictionary，并且value.size()为0，返回true。<br>
	 *         如果value的类型为Map，并且value.size()为0，返回true。 否则返回false。
	 * @param value
	 *            被检查值。
	 */
	// public static boolean isEmpty(Object value) {
	// if (value == null) {
	// return true;
	// }
	// if ((value instanceof String) && (((String) value).trim().length() <= 0))
	// {
	// return true;
	// }
	// if ((value instanceof Object[]) && (((Object[]) value).length <= 0)) {
	// return true;
	// }
	// // 判断数组中的值是否全部为空null.
	// if (value instanceof Object[]) {
	// Object[] t = (Object[]) value;
	// for (int i = 0; i < t.length; i++) {
	// if (t[i] != null) {
	// return false;
	// }
	// }
	// return true;
	// }
	// if ((value instanceof Collection) && ((Collection) value).size() <= 0) {
	// return true;
	// }
	// if ((value instanceof Dictionary) && ((Dictionary) value).size() <= 0) {
	// return true;
	// }
	// if ((value instanceof Map) && ((Map) value).size() <= 0) {
	// return true;
	// }
	// return false;
	// }
	/**
	 * <b>Function</b> List<Integer> 转化为int[]
	 * 
	 * @param list
	 * @return
	 * @author ELLEX 2011-5-28 下午10:39:00
	 */
	public static int[] toIntArray(List<Integer> list) {
		int[] ret = new int[list.size()];
		for (int i = 0; i < ret.length; i++) {
			ret[i] = list.get(i);
		}
		return ret;
	}

	/**
	 * <b>Function</b> List<String> 转化为 String[]
	 * 
	 * @param list
	 * @return
	 * @author ELLEX 2011-10-14 下午1:23:49
	 */
	public static String[] toStringArray(List<String> list) {
		String[] ret = new String[list.size()];
		for (int i = 0; i < ret.length; i++) {
			ret[i] = list.get(i);
		}
		return ret;
	}

	/**
	 * <b>Function</b> 48～57为0到9十个阿拉伯数字； 65～90为26个大写英文字母<br>
	 * this function is uses to increase string,the word between 0-9 or A-Z. For
	 * ies: "009" -> "00A", "0AA"->"0AB"
	 * 
	 * @author ELLEX 2011-5-10 下午10:01:03
	 */
	public static String incString(String s) {

		if (s == null || s.length() == 0) {
			return "";
		}

		char[] cs = s.toUpperCase().toCharArray();
		int i = s.length();
		while (true) {
			if (i == 0) {
				throw new IllegalArgumentException("字符串溢出!");
			}
			i--;
			char c = cs[i];
			int asscii = (int) c;
			// if "Z" then continue
			if (asscii == 90) {
				// 若为"Z"需要同步,设置为进零,即"0Z"-->>"10"
				asscii = 48;
				cs[i] = (char) asscii;
				continue;
			}
			// if num=9 then num transform into "A"
			boolean flag = (asscii >= 48 && asscii <= 57) || (asscii >= 65 && asscii < 90);
			if (flag) {
				asscii = (asscii == 57) ? 65 : ++asscii;
				cs[i] = (char) asscii;
				break;
			} else {
				throw new IllegalArgumentException(" 存在非法字符,字符范围为'0-9 or A-Z!'");
			}
		}

		return String.valueOf(cs);
	}

	/**
	 * <b>Function</b> 48～57为0到9十个阿拉伯数字<br>
	 * ies: "009" -> "010"
	 * 
	 * @author ELLEX 2011-5-10 下午10:01:03
	 */
	public static String incStringNumic(String s) {

		if (s == null || s.length() == 0) {
			return "";
		}

		char[] cs = s.toUpperCase().toCharArray();
		int i = s.length();
		while (true) {
			if (i == 0) {
				throw new IllegalArgumentException("字符串溢出!");
			}
			i--;
			char c = cs[i];
			int asscii = (int) c;
			// if "Z" then continue
			if (asscii == 57) {
				asscii = 48;
				cs[i] = (char) asscii;
				continue;
			}
			// if num=9 then num transform into "A"
			boolean flag = (asscii >= 48 && asscii <= 57) || (asscii >= 65 && asscii < 90);
			if (flag) {
				asscii = (asscii == 57) ? 65 : ++asscii;
				cs[i] = (char) asscii;
				break;
			} else {
				throw new IllegalArgumentException(" 存在非法字符,字符范围为'0-9 or A-Z!'");
			}
		}

		return String.valueOf(cs);
	}

	/**
	 * <b>Function</b> 自增字符串,若字符串溢出,则自增字符串后直接自增"001" <br>
	 * this function is uses to increase string,the word between 0-9 or A-Z. For
	 * ies: "009" -> "00A", "0AA"->"0AB"
	 * 
	 * @param s
	 * @return
	 * @author ELLEX 2011-6-1 下午04:40:02
	 */
	public static String incStringAuto(String s) {
		try {
			return incString(s);
		} catch (Exception e) {
			return s + "001";
		}
	}

/**
	 * In order to make a fault when encountering the symbol "<"
	 *	,change "<" to "&lt;",for ies:
	 * the String str = specialSymbolsEscape(aaa<bb);
	 * the result is : str = aaa&ltbb;
	 * @author Keyj
	 * @param str
	 * @return
	 */
	public static String specialSymbolsEscape(String str) {
		String theString = doNotBlank(str);
		return (theString == null || "".equals(theString)) ? "" : theString.replaceAll("<", "&lt;");
	}

	/**
	 * 除去字符串前后的空格
	 * */
	public static String doNotBlank(String str) {
		String theString = doNullStr(str);
		return (theString == null || "".equals(theString)) ? "" : str.trim();
	}

	/**
	 * <b>Function</b> 如果字符串为NULL 返回“”
	 * 
	 * @param str
	 * @return
	 * @author ELLEX 2011-5-14 下午05:31:01
	 */
	public static String doNullStr(String str) {
		if (str == null || STRING_NULL.equals(str)) {
			return "";
		}
		return str;
	}

	/**
	 * <b>Function</b> 如果字符串为NULL 返回“”
	 * 
	 * @param str
	 * @return
	 * @author ELLEX 2011-5-14 下午05:31:01
	 */
	public static String getString(Object str) {
		if (str == null || STRING_NULL.equals(str)) {
			return "";
		}
		return str.toString();
	}

	/**
	 * <b>Function</b> 如果字符串为NULL 返回“”
	 * 
	 * @param str
	 * @return
	 * @author ELLEX 2011-5-14 下午05:31:01
	 */
	public static String getString(Object str, String defaultValue) {
		if (str == null || STRING_NULL.equals(str)) {
			return defaultValue;
		}
		return str.toString();
	}

	/**
	 * <b>Function</b> 将传入的ID列表转换成数据库的字符串，如：'aaaa','bbbb'
	 * 
	 * @param strList
	 * @return
	 * @author ELLEX 2010-12-15 下午01:44:57
	 */
	public static String collToDbString(Collection<String> strList) {
		StringBuffer result = new StringBuffer();
		if (strList == null || strList.size() == 0) {
			return result.toString();
		}
		for (String str : strList) {
			str = replaceString(str, "'", "''", false);
			result.append("'").append(str).append("'").append(",");
		}
		return result.substring(0, result.length() - 1);
	}

	/**
	 * <b>Function</b> 将传入的ID列表转换成数据库的字符串，如：'aaaa','bbbb'
	 *
	 * @param strList
	 * @return
	 * @author ELLEX 2010-12-15 下午01:44:57
	 */
	public static String collToDbStringByObject(Collection strList) {
		StringBuffer result = new StringBuffer();
		if (strList == null || strList.size() == 0) {
			return result.toString();
		}
		for (Object object : strList) {
			String str =object==null?"":object.toString();
			str = replaceString(str, "'", "''", false);
			result.append("'").append(str).append("'").append(",");
		}
		return result.substring(0, result.length() - 1);
	}



	/**
	 * 
	 * <b>Function</b> 将字符串数据转变成SQL 中IN的语句，如 [a,b,c]->'a','b','c'
	 * 
	 * @param array
	 * @return
	 * @author ELLEX 2010-12-15 下午01:45:13
	 */
	public static String arrayToDBStr(String[] array) {
		if (array == null) {
			return "''";
		}
		StringBuffer result = new StringBuffer();
		String split = "";
		for (String str : array) {
			str = replaceString(str, "'", "''", false);
			result.append(split).append("'").append(str).append("'");
			split = ",";
		}
		return result.toString();
	}

	/**
	 * 
	 * <b>Function</b> 将逗号分隔的字符串SQL 中OR的语句,以便利用到索引，<br>
	 * 如 a,b,c->(fieldName='a' OR fieldName='b' OR fieldName='c')
	 * 
	 * @param array
	 *            字段值
	 * @param fieldName
	 *            字段名
	 * @return
	 * @author ELLEX 2010-12-15 下午01:45:27
	 */

	public static String arrayToDBSqlStr(String[] array, String fieldName) {
		if (array == null) {
			return "''";
		}
		StringBuffer result = new StringBuffer();
		String split = "";
		result.append(" (");
		for (String str : array) {
			str = replaceString(str, "'", "''", false);
			result.append(split).append(fieldName).append("=").append("'").append(str).append("'");
			split = " OR ";
		}
		result.append(") ");
		return result.toString();
	}

	/**
	 * 
	 * <b>Function</b> 将逗号分隔的字符串SQL 中IN的语句，如 a,b,c->'a','b','c'
	 * 
	 * @param srcStr
	 * @return
	 * @author ELLEX 2010-12-15 下午01:45:27
	 */

	public static String stringToDBStr(String srcStr) {
		String[] tempAttr = Str2Utils.stringToArray(srcStr, ',', true);
		return arrayToDBStr(tempAttr);
	}

	/**
	 * 
	 * <b>Function</b> 将字符串数据转换为一个List集合
	 * 
	 * @param array
	 * @return
	 * @author ELLEX 2010-12-15 下午01:45:36
	 */
	public static List<String> arrayToList(String[] array) {
		List<String> result = new ArrayList<String>();

		if (array == null || array.length == 0) {
			return result;
		}
		for (String item : array) {
			result.add(item);
		}
		return result;
	}

	/**
	 * 
	 * <b>Function</b> 数字字符串转化为整数
	 * 
	 * @param srcStr
	 *            待转化的数字字符串
	 * @param defaultValue
	 *            当srcStr为null,空字符串,或者不能转换为数字时返回的缺省值
	 * @return 返回由数字字符串转化成的数字，当srcStr为空或空字符串时，返回缺省值defaultValue
	 * 
	 * @author ELLEX 2010-12-15 下午01:45:56
	 */
	public static int getInt(String srcStr, int defaultValue) {
		if (Str2Utils.isEmpty(srcStr)) {
			return defaultValue;
		}
		int result = defaultValue;
		try {
			Double db = new Double(srcStr);
			result = db.intValue();
		} catch (NumberFormatException e) {
			e.printStackTrace();
		}
		return result;
	}

	/**
	 * <b>Function</b> 获取Integer字符串
	 * 
	 * @param theObj
	 * @return
	 * @author ELLEX 2012-6-2 下午2:22:49
	 */
	public static String getIntValue(Object theObj) {
		int intValue = 0;
		if (theObj == null) {
			return String.valueOf(intValue);
		}
		if (theObj instanceof Integer) {
			intValue = ((Integer) theObj).intValue();
		}
		if (theObj instanceof BigInteger) {
			intValue = ((BigInteger) theObj).intValue();
		}
		if (theObj instanceof Float) {
			intValue = (int) ((Float) theObj).floatValue();
		}
		if (theObj instanceof BigDecimal) {
			intValue = ((BigDecimal) theObj).intValue();
		}
		return String.valueOf(intValue);
	}

	/**
	 * 
	 * <b>Function</b> 数字字符串转化为整数，在转化时发生异常，则返回0
	 * 
	 * @param srcStr
	 *            待转化的数字字符串
	 * @return 返回由数字字符串转化成的整数，当srcStr为空或空字符串时，返回0
	 * 
	 * @author ELLEX 2010-12-15 下午01:46:16
	 */
	public static int getInt(String srcStr) {
		return getInt(srcStr, 0);
	}

	public static int getInt(Object srcStr) {
		return getInt(Str2Utils.getString(srcStr), 0);
	}

	/**
	 * <b>Function</b>数字字符串转化为整数和小数部分,若小数为零,则返回整数
	 * 
	 * @param srcStr
	 *            待转化的数字字符串
	 * @return 例如:5.50->5.5, 5.0->5
	 * @author ELLEX 2013-2-2 下午9:02:08
	 */
	public static String getDoubleWithDigts(String srcStr) {
		double d = getDouble(srcStr);
		String coureseScore;
		try {
			if (d == (int) d) {
				coureseScore = String.valueOf((int) d);
			} else {
				coureseScore = String.valueOf(d);
			}
		} catch (Exception e) {
			return String.valueOf(d);
		}
		return coureseScore;
	}

	/**
	 * 
	 * <b>Function</b> 判断传入的字符串是否为数字
	 * 
	 * @param str
	 * @return
	 * @author ELLEX 2010-12-15 下午01:46:35
	 */
	public static boolean isNumber(String str) {
		if (Str2Utils.isEmpty(str)) {
			return false;
		}
		for (int i = 0; i < str.length(); i++) {
			char a = str.charAt(i);
			if (!Character.isDigit(a)) {
				return false;
			}
		}
		return true;
	}

	/**
	 * <b>Function</b> 判断传入的字符串是否为浮点型数字
	 * 
	 * @param str
	 * @return
	 * @author ELLEX 2012-6-23 上午12:56:37
	 */
	public static boolean isNumberOfFloat(String str) {
		try {
			Float.valueOf(str);
		} catch (Exception e) {
			return false;
		}
		return true;
	}

	/**
	 * 
	 * <b>Function</b> 数字字符串转化为双精数字
	 * 
	 * @param srcStr
	 *            待转化的数字字符串
	 * @param defaultValue
	 *            当srcStr为空或空字符串时返回的缺省值
	 * @return 返回由数字字符串转化成的数字，当srcStr为空或空字符串时，则返回缺省值defaultValue
	 * 
	 * @author ELLEX 2010-12-15 下午01:46:56
	 */
	public static double getDouble(String srcStr, double defaultValue) {
		if (isEmpty(srcStr)) {
			return defaultValue;
		}
		double result = defaultValue;
		try {
			Double db = new Double(srcStr);
			result = db.doubleValue();
		} catch (NumberFormatException e) {
			e.printStackTrace();
		}
		return result;
	}

	/**
	 * <b>Function</b> 格式化浮点数，小数点后几位
	 * 
	 * @param number
	 *            数值
	 * @param digit
	 *            小数点个数
	 * @return
	 * @author ELLEX 2012-7-29 上午1:00:10
	 */
	public static float getFloat(float number, int digit) {
		try {
			float result = ((new BigDecimal(number)).setScale(digit, BigDecimal.ROUND_HALF_UP)).floatValue();
			return result;
		} catch (Exception e) {
			return 0.0f;
		}

	}

	public static double getDouble(double number, int digit) {
		try {
			double result = ((new BigDecimal(number)).setScale(digit, BigDecimal.ROUND_HALF_UP)).doubleValue();
			return result;
		} catch (Exception e) {
			return 0.0f;
		}

	}
	public static BigDecimal getBigDecimal(String str) {
		try {
			BigDecimal result = new BigDecimal(str);
			return result;
		} catch (Exception e) {
			return new BigDecimal(0);
		}

	}

	/**
	 * <b>Function</b> 格式化浮点数，小数点后几位
	 * 
	 * @param number
	 *            数值
	 * @param digit
	 *            小数点个数
	 * @return
	 * @author ELLEX 2012-7-29 上午1:00:10
	 */
	public static float getFloat(Object number, int digit) {
		try {
			float result = getFloat(getFloat(Str2Utils.getString(number)), digit);
			return result;
		} catch (Exception e) {
			return 0.0f;
		}

	}

	/**
	 * <b>Function</b> 格式化浮点数
	 * 
	 * @param str
	 * @return
	 * @author ELLEX 2012-8-6 下午1:41:22
	 */
	public static float getFloat(String str) {
		try {
			return Float.valueOf(str);
		} catch (Exception e) {
		}
		return 0f;
	}

	/**
	 * 
	 * <b>Function</b> 数字字符串转化为双精数字，在转化时发生异常，则返回0
	 * 
	 * @param srcStr
	 *            待转化的数字字符串
	 * @return 返回由数字字符串转化成的数字，当srcStr为空或空字符串时，则返回0。
	 * 
	 * @author ELLEX 2010-12-15 下午01:47:19
	 */
	public static double getDouble(String srcStr) {
		return getDouble(srcStr, 0);
	}

	/**
	 * 
	 * <b>Function</b> 数字字符串转化为长整型
	 * 
	 * @param srcStr
	 *            待转化的数字字符串
	 * @param defaultValue
	 *            当srcStr为空或空字符串时返回的缺省值
	 * @return 返回由数字字符串转化成的数字，当srcStr为空或空字符串时，则返回缺省值defaultValue
	 * 
	 * @author ELLEX 2010-12-15 下午01:47:35
	 */
	public static long getLong(String srcStr, long defaultValue) {
		if (isEmpty(srcStr)) {
			return defaultValue;
		}
		long result = defaultValue;
		try {
			Double db = new Double(srcStr);
			result = db.longValue();
		} catch (NumberFormatException e) {
			e.printStackTrace();
		}
		return result;
	}

	/**
	 * 
	 * <b>Function</b> 数字字符串转化为长整型，在转化时发生异常，则返回0
	 * 
	 * @param srcStr
	 *            待转化的数字字符串
	 * @return 返回由数字字符串转化成的数字，当srcStr为空或空字符串时，则返回0。
	 * @author ELLEX 2010-12-15 下午01:50:21
	 */
	public static long getLong(String srcStr) {
		return getLong(srcStr, 0);
	}

	/**
	 * 字符串转化为布尔型
	 * 
	 * @param srcStr
	 *            String 待转化的字符串
	 * @param defaultValue
	 *            boolean 当字符串为空或为null时返回的值
	 * @return boolean 返回转化化的布尔值，只有当srcStr为字符串“true”(忽略大小写)或者为"1"时才返回true， <BR>
	 *         如果在转化时发生异常（只有为null时），则返回缺省值defaultValue
	 */
	public static boolean getBoolean(String srcStr, boolean defaultValue) {
		if (isEmpty(srcStr)) {
			return defaultValue;
		}
		boolean result = defaultValue;
		String flagTrue="true";
		String flagYes="yes";
		if (flagTrue.equalsIgnoreCase(srcStr.trim()) || flagYes.equalsIgnoreCase(srcStr.trim())) {
			result = true;
		}
		return result;
	}

	/**
	 * 字符串转化为布尔型. <BR>
	 * 只有当srcStr为字符串“true”(忽略大小写)时才返回true，其它都返回false, 包括srcStr为null
	 * 
	 * @param srcStr
	 *            String 待转化的字符串
	 * @return boolean 返回转化化的布尔值，
	 */
	public static boolean getBoolean(String srcStr) {
		return getBoolean(srcStr, false);
	}

	/**
	 * 双精数字格式化，返回字符串
	 * 
	 * @param db
	 *            double 待格式化的双精数字
	 * @param fmt
	 *            String 格式化样式，参见类说明， <BR>
	 *            fmt非法时，db将按原样转化为字符串后返回。
	 * @return String 格式化后的数字，以字符串方式返回
	 */
	public static String getNumFormat(double db, String fmt) {
		String retu = "";
		if (null == fmt || "".equals(fmt.trim())) {
			return Double.toString(db);
		}

		try {
			DecimalFormat decimalformat = new DecimalFormat(fmt);
			retu = decimalformat.format(db);
			decimalformat = null;
		} catch (IllegalArgumentException iaex) {
			retu = Double.toString(db);
		}
		return retu;
	}

	/**
	 * 双精数字格式化，把入参中的双精数格式化为带两位小数的数字字符串
	 * 
	 * @param db
	 *            double 待格式化的双精数字
	 * @return String 格式化为两位小数的数字字符串
	 */
	public static String getNumFormat(double db) {
		return getNumFormat(db, "0.00");
	}

	/**
	 * 数字字符串格式化，返回字符串
	 * 
	 * @param numStr
	 *            String 待格式化的数字字符串， <BR>
	 *            如果numStr参数不是的数字则不进行格式化，按原样返回
	 * @param fmt
	 *            String 格式化样式，参见类说明 <BR>
	 *            fmt非法时，将把numStr按原样返回。
	 * @return String 格式化后的字符串
	 */
	public static String getNumFormat(String numStr, String fmt) {
		double db = getDouble(numStr, 0);
		return getNumFormat(db, fmt);
	}

	/**
	 * 数字字符串格式化，把入参中的数字字符串格式化为带两位小数的数字字符串
	 * 
	 * @param numStr
	 *            String 待格式化的数字字符串， <BR>
	 *            如果numStr参数不是的数字则不进行格式化，按原样返回
	 * @return String 格式化为两位小数的数字字符串
	 */
	public static String getNumFormat(String numStr) {
		return getNumFormat(numStr, "0.00");
	}

	/**
	 * 普通字符串转化为网页中可显示的，如回车转化为&lt;br&gt;.
	 * 
	 * @param str
	 *            String 待转化的字符串
	 * @return String 转化后的字符串
	 */
	public static String htmlEncode(String str) {
		String retu = null;
		if (null == str || "".equals(str.trim())) {
			retu = str;
		} else {
			String html = str;
			html = replaceString(html, "&", "&amp;");
			html = replaceString(html, "<", "&lt;");
			html = replaceString(html, ">", "&gt;");
			html = replaceString(html, "\r\n", "\n");
			html = replaceString(html, "\n", "<br>");
			html = replaceString(html, "\t", "    ");
			html = replaceString(html, " ", "&nbsp;");
			html = replaceString(html, "\"", "&quot;");
			retu = html;
			html = null;
		}
		return retu;
	}

	/**
	 * 字符串替换，把str字符串中的所有oldStr子串替换为newStr字串
	 * 
	 * @param srcStr
	 *            String 将被替换的字符串，为null时不执行任何替换操作
	 * @param oldStr
	 *            String 将被替换的子串，为null或为空字符串时不执行替换操作
	 * @param newStr
	 *            String 将被替换成的子串，为null时不执行替换操作
	 * @param ignoreCase
	 *            boolean 是否忽略大小写，true表忽略大小写，false表大小写敏感。
	 * @return String 替换后的字符串
	 */
	public static String replaceString(String srcStr, String oldStr, String newStr, boolean ignoreCase) {
		if (srcStr == null || oldStr == null) {
			return null;
		}
		String result = srcStr;
		String tempStr = srcStr;
		if (ignoreCase) {
			tempStr = srcStr.toUpperCase();
			oldStr = oldStr.toUpperCase();
		}
		int pos = tempStr.indexOf(oldStr);
		while (pos != -1) {
			result = result.substring(0, pos) + newStr + result.substring(pos + oldStr.length());
			pos = tempStr.indexOf(oldStr, pos + newStr.length());
		}
		return result;
	}

	/**
	 * 字符串替换，把str字符串中的所有oldStr子串替换为newStr字串(大小写敏感)
	 * 
	 * @param srcStr
	 *            String 将被替换的字符串，为null时不执行任何替换操作
	 * @param oldStr
	 *            String 将被替换的子串，为null或为空字符串时不执行替换操作
	 * @param newStr
	 *            String 将被替换成的子串，为null时不执行替换操作
	 * @return String 替换后的字符串
	 */
	public static String replaceString(String srcStr, String oldStr, String newStr) {
		return replaceString(srcStr, oldStr, newStr, false);
	}

	/**
	 * 字符串按指定分隔符分解为一个数组（大小写敏感）. <BR>
	 * 例子： <BR>
	 * String[] array = Str2Utils.splictString("AA/BBB/CCC//DDDD//" , "/" ); <BR>
	 * 结果： <BR>
	 * array[0]="AA" array[1]="BBB" array[2]="CCC" array[3]="DDDD"
	 * 
	 * @param srcStr
	 *            String 源字符串
	 * @param split
	 *            String 分隔符
	 * @return String[] 字符串数组, <BR>
	 *         源字符串为null或为空字符串时，返回长度为1的数组，元素值为空字符串 <BR>
	 *         分隔符为null或为空字符串时，返回长度为1的数组，元素值为源字符串
	 */
	public static String[] split(String srcStr, String split, boolean trim) {
		if (isEmpty(srcStr) || isEmpty(split)) {
			return null;
		}
		if (trim) {
			srcStr = trim(srcStr, split);
		}
		return split(srcStr, split);
	}

	/**
	 * 功能简述 :把字符串放入一个数组
	 * 
	 * @param srcStr
	 *            要被放入的字符串
	 * @param split
	 *            间隔符
	 * @return 转换后的数组,srcStr或split ＝ null 或 "" 返回null
	 */
	public static String[] split(String srcStr, String split) {
		if (isEmpty(srcStr) || isEmpty(split)) {
			return null;
		}
		int intArraySize = subStringCount(srcStr, split);
		// 如果为-1则返回
		if (intArraySize == -1) {
			return null;
		}

		srcStr += split;

		String[] strRetArr = new String[intArraySize + 1];
		int intPos = srcStr.indexOf(split);
		int intArrayPos = 0;
		while (intPos != -1) {
			strRetArr[intArrayPos++] = srcStr.substring(0, intPos);
			srcStr = srcStr.substring(intPos + split.length());
			intPos = srcStr.indexOf(split);
		}

		return strRetArr;
	}

	/**
	 * 功能简述 :在一个字符串中查找字符串个数(不区分大小写)
	 * 
	 * @param srcStr
	 *            要被查询的字符串
	 * @param subStr
	 *            要查找的字符串
	 * @return 找到的个数
	 */
	public static int subStringCount(String srcStr, String subStr) {
		if (isEmpty(srcStr) || isEmpty(subStr)) {
			return 0;
		}
		int result = 0;
		int intPos = srcStr.toUpperCase().indexOf(subStr.toUpperCase());
		while (intPos != -1) {
			result++;
			intPos = srcStr.toUpperCase().indexOf(subStr.toUpperCase(), intPos + subStr.length());
		}
		return result;
	}

	/**
	 * 用指定的分隔符把字符串数组合并成一个字符串. 数组为null或长度为0时返回空字符串 <BR>
	 * 例子： <BR>
	 * String[] array = {"1",null,"","3"}; <BR>
	 * Str2Utils.arrayToString(array,"|"); <BR>
	 * 返回结果：1|||3
	 * 
	 * @param array
	 *            String[] 待合并的数组
	 * @param split
	 *            String 数组各元素合并后，它们之间的分隔符，为null时用空字符串代替
	 * @return String 合并后的字符串
	 */
	public static String arrayToString(String[] array, String split) {
		if (null == array || 0 == array.length) {
			return "";
		}
		if (null == split) {
			split = "";
		}
		StringBuffer strBuf = new StringBuffer("");
		int len = array.length;
		for (int i = 0; i < len - 1; i++) {
			strBuf.append((null == array[i]) ? "" : array[i]).append(split);
		}
		strBuf.append((null == array[len - 1]) ? "" : array[len - 1]);

		return strBuf.toString();
	}

	/**
	 * 用默认分隔符 (逗号), 把字符串数组合并成一个字符串. 数组为null或长度为0时返回空字符串
	 * 
	 * @param array
	 *            String[] 待合并的数组
	 * @return String 合并后的字符串
	 */
	public static String arrayToString(String[] array) {
		return arrayToString(array, ",");
	}

	/**
	 * 判断字符串是否为null或为空字符串（包括只含空格的字符串）
	 * 
	 * @param str
	 *            String 待检查的字符串
	 * @return boolean 如果为null或空字符串（包括只含空格的字符串）则返回true，否则返回false
	 */
	public static boolean isEmpty(String str) {
		return (null == str || "".equals(str.trim())) ? true : false;
	}

	/**
	 * 判断字符串是否不为空
	 * 
	 * @param str
	 *            String
	 * @return boolean
	 */
	public static boolean isNotEmpty(String str) {
		if (isEmpty(str)) {
			return false;
		} else {
			return true;
		}
	}

	/**
	 * 从字符串中得到指定位置的子串（按分隔符分隔，大小写敏感）. <BR>
	 * 例子： <BR>
	 * Str2Utils.decomposeString("a||b|c|d","|",1); <BR>
	 * Str2Utils.decomposeString("a||b|c|d","|",2); <BR>
	 * Str2Utils.decomposeString("a||b|c|d","|",3); <BR>
	 * Str2Utils.decomposeString("a||b|c|d","|",4); <BR>
	 * Str2Utils.decomposeString("a||b|c|d","|",5); <BR>
	 * 返回结果： <BR>
	 * a,空字符串,b,c,d
	 * 
	 * @param srcStr
	 *            String 源字符串
	 * @param split
	 *            String 分隔符
	 * @param pos
	 *            int 位置，从1开始
	 * @return String 返回指定位置的子串。 <BR>
	 *         当分隔符为null或为空字符串时返回源字符串； <BR>
	 *         当源字符串为null或为空字符串时返回空字符串； <BR>
	 *         当指定位置小于1或大于分隔符个数-1时返回空字符串。
	 */
	public static String decomposeString(String srcStr, String split, int pos) {
		String retu = "";
		if (null == srcStr || "".equals(srcStr.trim())) {
			return "";
		}

		if (pos <= 0) {
			return "";
		}

		if (null == split || "".equals(split)) {
			return srcStr;
		}

		srcStr = srcStr + split;
		String tmpStr = srcStr;

		int splitLen = split.length();
		int tmpLen = tmpStr.length();

		for (int i = 0; i < pos - 1; i++) {
			int tmpPosi = tmpStr.indexOf(split);
			if (tmpPosi < 0 || tmpPosi + splitLen >= tmpLen) {
				tmpStr = split;
				break;
			} else {
				tmpStr = tmpStr.substring(tmpPosi + splitLen);
			}
		}
		retu = tmpStr.substring(0, tmpStr.indexOf(split));
		return retu;
	}

	/**
	 * 从字符串中得到指定位置的子串（按分隔符 | 分隔）.
	 * 
	 * @param srcStr
	 *            String 源字符串
	 * @param pos
	 *            int 位置，从1开始
	 * @return String 返回指定位置的子串。 <BR>
	 *         当分隔符为null或为空字符串时返回源字符串； <BR>
	 *         当源字符串为null或为空字符串时返回空字符串； <BR>
	 *         当指定位置小于1或大于分隔符个数-1时返回空字符串。
	 */
	public static String decomposeString(String srcStr, int pos) {
		return decomposeString(srcStr, "|", pos);
	}

	/**
	 * 删除指定的前导、后导子串（大小写敏感）. <br>
	 * 例子： <br>
	 * Str2Utils.trim("and and username = '123' and password = 'abc' and ",
	 * "and "); <br>
	 * 结果：username = '123' and password = 'abc'
	 * 
	 * @param srcStr
	 *            String 待删除的字符串
	 * @param removeChar
	 *            char 子串
	 * @return String 处理后的字符串
	 */
	public static String trim(String srcStr, char removeChar) {
		if (srcStr == null) {
			return null;
		}
		srcStr = srcStr.trim();
		int loIntBegin = 0, loIntEnd = 0;
		int loIntLen = srcStr.length();
		for (int i = 0; i < loIntLen; i++) {
			if (srcStr.charAt(i) == removeChar) {
				loIntBegin++;
			} else {
				break;
			}
		}
		for (int i = 0; i < loIntLen; i++) {
			if (srcStr.charAt(loIntLen - 1 - i) == removeChar) {
				loIntEnd++;
			} else {
				break;
			}
		}
		return srcStr.substring(loIntBegin, loIntLen - loIntEnd);
	}

	/**
	 * 从源字符串中从第一个字符开始取出给定长度的字串. <BR>
	 * 源字符串长度大于len时，尾巴追加一个appendStr串
	 * 
	 * @param srcStr
	 *            String 源字符串
	 * @param len
	 *            int 取出的长度
	 * @param omitStr
	 *            String 追加的字符串（常用的appendStr为...）
	 * @return String 取出的子串
	 */
	public static String clip(String srcStr, int len, String omitStr) {
		if (null == srcStr || "".equals(srcStr)) {
			return srcStr;
		}
		if (len <= 0) {
			return "";
		}

		if (null == omitStr) {
			omitStr = "";
		}

		int sourceLen = srcStr.length();
		if (len >= sourceLen) {
			return srcStr;
		} else {
			return srcStr.substring(0, len) + omitStr;
		}
	}

	/**
	 * 将null字符串转换为空串，方便HTML的显示
	 * 
	 * @param srcStr
	 *            待处理的字符串
	 * @return String 处理的的字符串
	 */
	public static String toVisualHtmlString(String srcStr) {
		if (srcStr == null || "".equals(srcStr)) {
			return "&nbsp;";
		} else {
			return srcStr;
		}
	}

	/**
	 * 将null字符串转换为空串
	 * 
	 * @param srcStr
	 *            待处理的字符串
	 * @return String 处理的的字符串
	 */
	public static String toVisualString(String srcStr) {
		if (srcStr == null || "".equals(srcStr)) {
			return "";
		} else {
			return srcStr;
		}
	}

	/**
	 * 将字段填充到指定的长度
	 * 
	 * @param srcStr
	 *            String 操作字符串
	 * @param length
	 *            int 指定长度
	 * @param withChar
	 *            char 填充的字符
	 * @param isPadToEnd
	 *            boolean 是否填充在字符的尾部 true ：是 ,false:填充在头部
	 * @return String
	 */
	public static String pad(String srcStr, int length, char withChar, boolean isPadToEnd) {
		if (srcStr == null) {
			return null;
		}
		if (srcStr.length() >= length) {
			return srcStr;
		}

		StringBuffer sb = new StringBuffer(srcStr);
		for (int i = 0; i < length - srcStr.length(); i++) {
			if (isPadToEnd) {
				sb.append(withChar);
			} else {
				sb.insert(0, withChar);
			}
		}
		return sb.toString();

	}

	/**
	 * 功能简述 :把字符串放入一个数组 系统会自动执行删除字符串首尾的多余的间隔符。如 ,abc,123,, 将自动变成 abc,123
	 * 
	 * @param srcStr
	 *            要被放入的字符串
	 * @param split
	 *            间隔符
	 * @param trim
	 *            自动删除首尾的间隔符
	 * @return 转换后的数组
	 */
	public static String[] stringToArray(String srcStr, char split, boolean trim) {
		if (isEmpty(srcStr)) {
			return null;
		}
		if (trim) {
			srcStr = trim(srcStr, "" + split);
		}
		return stringToArray(srcStr, "" + split);
	}

	/**
	 * 功能简述 :把字符串放入一个数组 系统会自动执行删除字符串首尾的多余的间隔符。如 ,abc,123,, 将自动变成 abc,123
	 * 
	 * @param srcStr
	 *            要被放入的字符串
	 * @param split
	 *            间隔符
	 * @param trim
	 *            自动删除首尾的间隔符
	 * @return 转换后的数组
	 */
	public static String[] stringToArray(String srcStr, String split, boolean trim) {
		if (Str2Utils.isEmpty(srcStr)) {
			return null;
		}
		if (trim) {
			srcStr = trim(srcStr, split + "");
		}
		return stringToArray(srcStr, split);
	}

	/**
	 * 功能简述 :把字符串放入一个数组
	 * 
	 * @param srcStr
	 *            要被放入的字符串
	 * @param split
	 *            间隔符
	 * @return 转换后的数组
	 */
	public static String[] stringToArray(String srcStr, char split) {
		return stringToArray(srcStr, "" + split);
	}

	/**
	 * 功能简述 :把字符串放入一个数组
	 * 
	 * @param srcStr
	 *            要被放入的字符串
	 * @param split
	 *            间隔符
	 * @return 转换后的数组,失败返回 null
	 */
	public static String[] stringToArray(String srcStr, String split) {
		if (Str2Utils.isEmpty(srcStr)) {
			return null;
		}
		srcStr = trim(srcStr, split + "");

		int intArraySize = subStringCount(srcStr, split);
		// 如果为-1则返回
		if (intArraySize == -1) {
			return null;
		}

		srcStr += split;

		String[] strRetArr = new String[intArraySize + 1];
		int intPos = srcStr.indexOf(split);
		int intArrayPos = 0;
		while (intPos != -1) {
			strRetArr[intArrayPos++] = srcStr.substring(0, intPos);
			srcStr = srcStr.substring(intPos + split.length());
			intPos = srcStr.indexOf(split);
		}

		return strRetArr;
	}

	/**
	 * 将字符分隔的字符串转换为List
	 * 
	 * @param srcStr
	 *            字符分隔的字符串
	 * @param splitChar
	 *            分隔字符
	 * @param trim
	 *            是否去除首尾多余字符
	 * @return
	 */
	public static List<String> stringToList(String srcStr, char splitChar, boolean trim) {
		return stringToList(srcStr, "" + splitChar, trim);
	}

	/**
	 * 将字符分隔的字符串转换为List
	 * 
	 * @param srcStr
	 *            字符分隔的字符串
	 * @param splitChar
	 *            分隔字符
	 * @return
	 */
	public static List<String> stringToList(String srcStr, char splitChar) {
		return stringToList(srcStr, "" + splitChar, false);
	}

	/**
	 * 将字符分隔的字符串转换为List
	 * 
	 * @param srcStr
	 *            字符分隔的字符串
	 *            分隔字符
	 * @return
	 */
	public static List<String> stringToList(String srcStr, String splitStr) {
		return stringToList(srcStr, splitStr, false);
	}

	/**
	 * 将字符分隔的字符串转换为List
	 * 
	 * @param srcStr
	 *            字符分隔的字符串
	 *            分隔字符
	 * @param trim
	 *            是否去除首尾多余字符
	 * @return
	 */
	public static List<String> stringToList(String srcStr, String splitStr, boolean trim) {
		if (srcStr == null) {
			return null;
		}
		List<String> resultList = new ArrayList<String>();
		if (!isNotEmpty(srcStr)) {
			return resultList;
		} else {
			String[] srcStrArr = stringToArray(srcStr, splitStr, trim);
			for (String item : srcStrArr) {
				resultList.add(item);
			}
			return resultList;
		}
	}

	/**
	 * 将字符串集成转换为分隔符分隔的字符串
	 * 
	 * @param collection
	 *            字符串集成
	 * @param split
	 *            分隔字符
	 * @return
	 */
	public static final String collToString(Collection<String> collection, String split) {
		StringBuffer sb = new StringBuffer();
		String tempSplit = "";
		for (String item : collection) {
			sb.append(tempSplit + item);
			tempSplit = split;
		}
		return sb.toString();
	}

	/** 以下是对js的escape,进行解码*/
	private final static byte[] VAL = { 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
			0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
			0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x00, 0x01, 0x02, 0x03, 0x04,
			0x05, 0x06, 0x07, 0x08, 0x09, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x3F,
			0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
			0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
			0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
			0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
			0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
			0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
			0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
			0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
			0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
			0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F };

	/**
	 * 对js的escape进行解码
	 * 
	 * @param sourceUrl
	 * @return
	 */
	public static String urlEncode(String sourceUrl) {
		Assert.notNull(sourceUrl,"url不能为空");
		StringBuffer sbuf = new StringBuffer();
		int i = 0;
		int len = sourceUrl.length();
		while (i < len) {
			int ch = sourceUrl.charAt(i);
			// 'A'..'Z' : as it was
			if ('A' <= ch && ch <= 'Z') {
				sbuf.append((char) ch);
				// 'a'..'z' : as it was
			} else if ('a' <= ch && ch <= 'z') {
				sbuf.append((char) ch);
				// '0'..'9' : as it was
			} else if ('0' <= ch && ch <= '9') {
				sbuf.append((char) ch);
				// unreserved : as it was
			} else if (ch == '-' || ch == '_'
					|| ch == '.' || ch == '!' || ch == '~' || ch == '*' || ch == '\'' || ch == '(' || ch == ')') {
				sbuf.append((char) ch);
			} else if (ch == '%') {
				int cint = 0;
				// %XX : map to ascii(XX)
				if ('u' != sourceUrl.charAt(i + 1)) {
					cint = (cint << 4) | VAL[sourceUrl.charAt(i + 1)];
					cint = (cint << 4) | VAL[sourceUrl.charAt(i + 2)];
					i += 2;
					// %uXXXX : map to unicode(XXXX)
				} else {
					cint = (cint << 4) | VAL[sourceUrl.charAt(i + 2)];
					cint = (cint << 4) | VAL[sourceUrl.charAt(i + 3)];
					cint = (cint << 4) | VAL[sourceUrl.charAt(i + 4)];
					cint = (cint << 4) | VAL[sourceUrl.charAt(i + 5)];
					i += 5;
				}
				sbuf.append((char) cint);
			} else {
				// 对应的字符未经过编码
				sbuf.append((char) ch);
			}
			i++;
		}
		return sbuf.toString();
	}

	/**
	 * 删除指定的前导、后导子串（大小写敏感）. <br>例子：
	 * <br>Str2Utils.trim("and and username = '123' and password = 'abc' and "
	 * ,"and "); <br>结果：username = '123' and password = 'abc'
	 * 
	 * @param srcStr String 待删除的字符串
	 * 
	 * @param ch String 子串
	 * 
	 * @return String 处理后的字符串
	 */
	public static String trim(String srcStr, String ch) {
		if (null == srcStr || "".equals(srcStr.trim())) {
			return srcStr;
		}
		if (null == ch || "".equals(ch)) {
			return srcStr;
		}

		if (ch.length() > srcStr.length()) {
			return srcStr;
		}

		if (srcStr.indexOf(ch) < 0) {
			return srcStr;
		}

		// 删除前导
		int chLen = ch.length();

		//表示还有前导
		while (srcStr.indexOf(ch, 0) == 0) {
			srcStr = srcStr.substring(chLen);
		}

		int strLen = srcStr.length();
		// 表示还有后导
		while (srcStr.indexOf(ch, (strLen - chLen)) == (strLen - chLen)) {
			srcStr = srcStr.substring(0, strLen - chLen);
			strLen = srcStr.length();
		}

		return srcStr;
	}

	/**
	 * 删除指定的前导（大小写敏感）. <br>例子：
	 * <br>Str2Utils.trim("and and username = '123' and password = 'abc' and "
	 * ,"and "); <br>结果：username = '123' and password = 'abc'
	 * 
	 * @param srcStr String 待删除的字符串
	 * 
	 * @param ch String 子串
	 * 
	 * @return String 处理后的字符串
	 */
	public static String ltrim(String srcStr, String ch) {
		if (null == srcStr || "".equals(srcStr.trim())) {
			return srcStr;
		}
		if (null == ch || "".equals(ch)) {
			return srcStr;
		}

		if (ch.length() > srcStr.length()) {
			return srcStr;
		}

		if (srcStr.indexOf(ch) < 0) {
			return srcStr;
		}

		// 删除前导
		int chLen = ch.length();
		// 表示还有前导
		if (srcStr.indexOf(ch, 0) == 0) {
			srcStr = srcStr.substring(chLen);
		}

		return srcStr;
	}

	/**
	 * 删除指定的后导（大小写敏感）. <br>例子：
	 * <br>Str2Utils.trim("and and username = '123' and password = 'abc' and "
	 * ,"and "); <br>结果：username = '123' and password = 'abc'
	 * 
	 * @param srcStr String 待删除的字符串
	 * 
	 * @param ch String 子串
	 * 
	 * @return String 处理后的字符串
	 */
	public static String rtrim(String srcStr, String ch) {
		if (null == srcStr || "".equals(srcStr.trim())) {
			return srcStr;
		}
		if (null == ch || "".equals(ch)) {
			return srcStr;
		}

		if (ch.length() > srcStr.length()) {
			return srcStr;
		}

		if (srcStr.indexOf(ch) < 0) {
			return srcStr;
		}

		// 删除后导
		int chLen = ch.length();
		int strLen = srcStr.length();
		// 表示还有后导
		if (srcStr.indexOf(ch, (strLen - chLen)) == (strLen - chLen)) {
			srcStr = srcStr.substring(0, strLen - chLen);
			strLen = srcStr.length();
		}

		return srcStr;
	}

	/**
	 * 功能描述: 判断字符串是否为null或为空字符串，则返回空字符串""
	 * 
	 *  str
	 *            String 待检查的字符串
	 * @return String 如果为null或空字符串（包括只含空格的字符串）则返回""，否则返回原字符串去空格
	 */
	public static String getNullBlankStr(Object obj) {

		if (obj == null) {
			return "";
		} else {
			return obj.toString().trim();
		}
	}

	/**
	 * 按指定宽度返回字符串，超过指定的长度则截取指定长度，并加"..."
	 * 
	 * @param str
	 *            String 处理的字符
	 * @param width
	 *            int 指定的宽度
	 * @return string 返回指定的宽度
	 */
	public static String getSubStr(String str, int width) {
		if (str == null || str.length() <= width) {
			return str;
		} else {
			return str.substring(0, width) + "...";
		}
	}

	/**
	 * 右补齐
	 * 
	 * @param s
	 * @param len
	 *            补齐到的目标长度
	 * @param c
	 *            补齐使用的字符
	 * @return
	 */
	public static String rightPad(String s, int len, char c) {
		if (s != null) {
			int needLen = len - s.length();
			if (needLen > 0) {
				for (int i = 0; i < needLen; i++) {
					s += c;
				}
			}
		}
		return s;
	}

	/**
	 * 左补齐
	 * 
	 * @param s
	 * @param len
	 *            左补齐到的目标长度
	 * @param c
	 *            补齐使用的字符
	 * @return
	 */
	public static String leftPad(String s, int len, char c) {
		if (s != null) {
			int needLen = len - s.length();
			if (needLen > 0) {
				for (int i = 0; i < needLen; i++) {
					s = c + s;
				}
			}
		}
		return s;
	}


	/**
	 * 将集合中的元素转为字符串数组
	 * 
	 * @param itemIds
	 * @return
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public static String[] collToArray(Collection itemIds) {
		if (itemIds == null) {
			return null;
		}
		return (String[]) itemIds.toArray(new String[0]);
	}

	public static String[] splitString(String sourceStr, String splitStr, boolean isTrim) {
		if ((sourceStr == null) || (splitStr == null)) {
			return null;
		}

		if (isTrim) {
			while (sourceStr.indexOf(splitStr) == 0) {
				sourceStr = sourceStr.substring(splitStr.length());
			}

			while (sourceStr.indexOf(splitStr, sourceStr.length() - splitStr.length()) > -1) {
				sourceStr = sourceStr.substring(0, sourceStr.length() - splitStr.length());
			}

		}

		if (("".equals(sourceStr)) || ("".equals(splitStr))) {
			return null;
		}

		return splitString(sourceStr, splitStr);
	}

	public static String[] splitString(String sourceStr, String splitStr) {
		if ((sourceStr == null) || (splitStr == null)) {
			return null;
		}

		if (("".equals(sourceStr)) || ("".equals(splitStr))) {
			return null;
		}

		int intArraySize = subStringCount(sourceStr, splitStr);

		if (intArraySize == -1) {
			return null;
		}

		sourceStr = sourceStr + splitStr;

		String[] strRetArr = new String[intArraySize + 1];
		int intPos = sourceStr.indexOf(splitStr);
		int intArrayPos = 0;
		while (intPos != -1) {
			strRetArr[(intArrayPos++)] = sourceStr.substring(0, intPos);
			sourceStr = sourceStr.substring(intPos + splitStr.length());
			intPos = sourceStr.indexOf(splitStr);
		}

		return strRetArr;
	}

	public static boolean isNullBlank(String str) {
		return ((null == str) || ("".equals(str.trim())));
	}

	public static boolean isNotBlank(String str) {
		return (!(isNullBlank(str)));
	}

	public static boolean isBlank(String str) {
		return isNullBlank(str);
	}

	public static String[] splitStringMd(String sourceStr, String splitStr) {
		if ((sourceStr == null) || (splitStr == null)) {
			return null;
		}
		if (("".equals(sourceStr)) || ("".equals(splitStr))) {
			return null;
		}
		int intArraySize = subStringCount(sourceStr, splitStr);

		if (intArraySize == -1) {
			return null;
		}
		if (intArraySize == 0) {
			return new String[] { sourceStr };
		}

		sourceStr = sourceStr + splitStr;

		String[] strRetArr = new String[intArraySize + 1];
		int intPos = sourceStr.indexOf(splitStr);
		int intArrayPos = 0;
		while (intPos != -1) {
			strRetArr[(intArrayPos++)] = sourceStr.substring(0, intPos);
			sourceStr = sourceStr.substring(intPos + splitStr.length());
			intPos = sourceStr.indexOf(splitStr);
		}

		return strRetArr;
	}

	public static String substring(String sourceStr, int len, String appendStr) {
		if ((null == sourceStr) || ("".equals(sourceStr))) {
			return sourceStr;
		}
		if (len <= 0) {
			return "";
		}

		if (null == appendStr) {
			appendStr = "";
		}

		int sourceLen = sourceStr.length();
		if (len >= sourceLen) {
			return sourceStr;
		}
		return sourceStr.substring(0, len) + appendStr;
	}

	public static String random(int length) {
		String retu = "";

		char[] letters = initLetters();
		// int[] numbers = initNumbers();

		for (int i = 0; i < length; ++i) {
			int d1 = (int) (Math.random() * 10.0D) % 2;
			if (d1 == 0) {
				int d2 = (int) (Math.random() * 100.0D) % 52;
				retu = retu + letters[d2];
			} else if (d1 == 1) {
				retu = retu + (int) (Math.random() * 10.0D);
			}
		}
		return retu;
	}

	public static String randomString(int length) {
		String retu = "";

		char[] letters = initLetters();

		for (int i = 0; i < length; ++i) {
			int d2 = (int) (Math.random() * 100.0D) % 52;
			retu = retu + letters[d2];
		}
		return retu;
	}

	public static String randomNumber(int length) {
		String retu = "";
		// int[] numbers = initNumbers();

		for (int i = 0; i < length; ++i) {
			retu = retu + (int) (Math.random() * 10.0D);
		}
		return retu;
	}

	private static char[] initLetters() {
		char[] ca = new char[52];
		int len = 26;
		int length=52;
		for (int i = 0; i < len; ++i) {
			ca[i] = (char) (65 + i);
		}
		for (int i = len; i < length; ++i) {
			ca[i] = (char) (71 + i);
		}
		return ca;
	}

	// private static int[] initNumbers() {
	// int[] na = new int[10];
	// for (int i = 0; i < 10; ++i)
	// na[i] = i;
	//
	// return na;
	// }

	public static String encrypt(String source, boolean flag) {
		if ((null == source) || ("".equals(source.trim()))) {
			return source;
		}

		String lsKey1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890abcdefghijklmnopqrstuvwxyz~!@#$%^&*(),.;[]{}";
		String lsKey2 = "&*()AD;[BFLCGH]{PQ}EI!JKRYZ1MSTXNO23UV,.Wcd45ef6lm7g@h0a#$nij8ob%^ptvz9ku~qrswxy";

		char[] chSource = source.toCharArray();

		StringBuffer strBuf = new StringBuffer(chSource.length);

		int i = 0;
		for (int len = chSource.length; i < len; ++i) {
			int pos;
			if (flag) {
				pos = lsKey1.indexOf(chSource[i]);
				if (pos >= 0) {
					strBuf.append(lsKey2.substring(pos, pos + 1));
				}else {
					strBuf.append(chSource[i]);
				}
			} else {
				pos = lsKey2.indexOf(chSource[i]);
				if (pos >= 0) {
					strBuf.append(lsKey1.substring(pos, pos + 1));
				}else {
					strBuf.append(chSource[i]);
				}
			}

		}

		return strBuf.toString();
	}

	public static String trimBegin(String sourceStr, String ch) {
		if ((null == sourceStr) || ("".equals(sourceStr.trim()))) {
			return sourceStr;
		}
		if ((null == ch) || ("".equals(ch))) {
			return sourceStr;
		}

		if (ch.length() > sourceStr.length()) {
			return sourceStr;
		}

		if (sourceStr.indexOf(ch) < 0) {
			return sourceStr;
		}

		int chLen = ch.length();

		if (sourceStr.indexOf(ch, 0) == 0) {
			sourceStr = sourceStr.substring(chLen);
		}

		return sourceStr;
	}

	public static String trimEnd(String sourceStr, String ch) {
		if ((null == sourceStr) || ("".equals(sourceStr.trim()))) {
			return sourceStr;
		}
		if ((null == ch) || ("".equals(ch))) {
			return sourceStr;
		}

		if (ch.length() > sourceStr.length()) {
			return sourceStr;
		}

		if (sourceStr.indexOf(ch) < 0) {
			return sourceStr;
		}

		int chLen = ch.length();
		int strLen = sourceStr.length();
		if (sourceStr.indexOf(ch, strLen - chLen) == strLen - chLen) {
			sourceStr = sourceStr.substring(0, strLen - chLen);
			strLen = sourceStr.length();
		}

		return sourceStr;
	}

	/**
	 * <b>Function</b> 转义
	 * 
	 * @param str
	 * @return
	 * @author ELLEX 2012-10-3 下午11:27:10
	 */
	public static String escape(String str) {
		str = str.replace("&", "&amp;");
		str = str.replace("<", "&lt;");
		str = str.replace(">", "&gt;");
		str = str.replace("\"", "&quot;");
		return str;
	}

	/**
	 * <b>Function</b> 反转义
	 * 
	 * @param str
	 * @return
	 * @author ELLEX 2012-10-3 下午11:27:26
	 */
	public static String unescape(String str) {
		str = str.replace("&amp;", "&");
		str = str.replace("&lt;", "<");
		str = str.replace("&gt;", ">");
		str = str.replace("&quot;", "\"");
		return str;
	}

	/**
	 * <b>Function</b> 首字母大写
	 * 
	 * @param value
	 * @return
	 * @author ELLEX 2012-11-18 下午9:55:40
	 */
	public static String upperCaseFirst(String value) {
		try {
			return value.substring(0, 1).toUpperCase() + value.subSequence(1, value.length());
		} catch (Exception e) {
			return null;
		}
	}

	/**
	 * <b>Function</b> 首字母小写
	 * 
	 * @param value
	 * @return
	 * @author ELLEX 2012-11-18 下午9:55:40
	 */
	public static String lowerCaseFirst(String value) {
		try {
			return value.substring(0, 1).toLowerCase() + value.subSequence(1, value.length());
		} catch (Exception e) {
			return null;
		}
	}

	/**
	 * <b>Function</b> 获取文件大小表示方式,例如超过1024K,则显示为1M,若小于1024,则以KB表示
	 * 
	 * @param size
	 *            文件大小(以KB为单位)
	 * @return 1.50MB 或者115KB
	 * @author ELLEX 2013-3-17 上午2:18:44
	 */
	public static String getSizeFormat(double size) {
		double dSize=1024;
		if (size >= dSize) {
			return Str2Utils.getNumFormat((double) size / 1024, "0.00") + "MB";
		} else {
			return Str2Utils.getNumFormat((double) size, "0.00") + "KB";
		}
	}
}
